Computed Tomography (“CT”) is a technique that noninvasively generates cross-sectional images of the linear attenuation coefficients (“LACs”) of materials in an object of interest. CT has been used extensively in medical and security applications such as for generating a scan of a brain or a scan of baggage at an airport. The LAC is a measure of the attenuation of X-rays as the X-rays pass through a certain material and is in units of inverse length (e.g., per centimeter). To generate the LACs, CT employs an X-ray source and an X-ray detector. The X-ray source transmits X-rays through the object with an initial intensity, and the X-ray detector, which is on the opposite side of the object from the source, measures the final intensities of the X-rays that pass through the object and impinge on pixels of a detector. CT collects measurements by positioning the source and detector at various angles relative to the object and collects the measurements of the final intensity at each angle. The measurements for an angle are referred to as a projection. The measurements of the intensities may be represented as a negative of a logarithm of a ratio of transmission data of a scan of the object to transmission data of a scan without the object (e.g., scan of air). Various techniques may be used to collect measurements at different angles relative to the object. For example, the source and detector may be stationary and the object may be rotated, the object may be stationary and the source and detector may be rotated, and multiple stationary transmitters and detectors may be positioned at different angles. CT algorithms then reconstruct from the collection of measurements a 3D image of the object that specifies the LAC for each volume element (“voxel”) with the volume of the object. The cross-sectional images are generated from the 3D image.
The forward model that links the unknown 3D volume with the CT measurements can be represented by the following equation:Pf=g where g represents a vector of the measurements, f represent a vector with an LAC for each voxel, and P represent a forward projection matrix. The forward projection matrix indicates which voxels an X-ray passed through in travelling from the X-ray source to the X-ray detector. The goal of CT is to determine f given P and g. Example values for P and g are given for a very simplified CT scan in the following:
                              [                                                    1                                            1                                            1                                            0                                            0                                            0                                            0                                            0                                            0                                                                    0                                            0                                            0                                            1                                            1                                            1                                            0                                            0                                            0                                                                    0                                            0                                            0                                            0                                            0                                            0                                            1                                            1                                            1                                                                    1                                            0                                            0                                            1                                            0                                            0                                            1                                            0                                            0                                                                    0                                            1                                            0                                            0                                            1                                            0                                            0                                            1                                            0                                                                    0                                            0                                            1                                            0                                            0                                            1                                            0                                            0                                            1                                                                    1                                            0                                            0                                            0                                            0                                            0                                            0                                            0                                            0                                                                    0                                            1                                            0                                            1                                            0                                            0                                            0                                            0                                            0                                                                    0                                            0                                            1                                            0                                            1                                            0                                            1                                            0                                            0                                                                    0                                            0                                            0                                            0                                            0                                            1                                            0                                            1                                            0                                                                    0                                            0                                            0                                            0                                            0                                            0                                            0                                            0                                            1                                              ]                ︸                    forward        ⁢                                  ⁢        model                    P        ︷              ⁢                  ⁢                            [                                                                      f                  1                                                                                                      f                  2                                                                                                      f                  3                                                                                                      f                  4                                                                                                      f                  5                                                                                                      f                  6                                                                                                      f                  7                                                                                                      f                  8                                                                                                      f                  9                                                              ]                ︸        ︷            unknown      f        =                    [                                            3                                                          4                                                          3                                                          3                                                          4                                                          3                                                          1                                                          2                                                          4                                                          2                                                          1                                      ]            ︸      ︷        measurements    g  
Conventional CT requires that the number of projections be roughly equal to the number of pixels in a projection. In practice, the number of projections that can be collected may be severely limited for various reasons. For example, some CT protocols require that the X-ray dose delivered to the object (e.g., baggage or patient) be limited. One way to reduce the dose is to limit the number of projections that are collected. As another example, CT systems that are flux-limited may employ long integration times per projection to collect adequate measurements. CT systems may be flux-limited because of dim sources (low current), large source-to-detector distances, small detector pixels, and/or highly attenuating objects. To increase throughput, a flux-limited CT system may have time to generate only a small number of projections. As another example, when the object is in motion (e.g., a beating human heart), a CT system may deliberately collect a limited number of projections to shorten the data acquisition time to reduce the artifacts associated with the object motion. As another example, some CT systems employ multiple source-detector pairs mounted on a stationary gantry (e.g., for scanning carry-on baggage at an airport.) The projections of such a CT system are limited by the number of sources.
When the number of projections is limited to one or more orders of magnitude smaller than the number pixels in a projection, a problem arises in that the reconstructed 3D image is generally polluted with streak artifacts. This problem is referred to as the few-view reconstruction problem. The few-view reconstruction problem arises because the number of unknowns (i.e., the number of voxels) is much greater than the number of linear equation represented by the projections and the measurements are noisy.